home *** CD-ROM | disk | FTP | other *** search
/ Aminet 49 / Aminet 49 (2002)(GTI - Schatztruhe)[!][Jun 2002].iso / Aminet / util / sys / AmberRAM.lha / AmberRAM / Source / support.c < prev   
Encoding:
C/C++ Source or Header  |  2002-02-11  |  7.1 KB  |  470 lines
  1. /*
  2.  
  3. File: support.c
  4. Author: Neil Cafferkey
  5. Copyright (C) 2001-2002 Neil Cafferkey
  6.  
  7. This program is free software; you can redistribute it and/or
  8. modify it under the terms of the GNU General Public License
  9. as published by the Free Software Foundation; either version 2
  10. of the License, or (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  20. MA 02111-1307, USA.
  21.  
  22. */
  23.  
  24.  
  25. #include "handler_protos.h"
  26.  
  27.  
  28.  
  29. /****i* ram.handler/SetString **********************************************
  30. *
  31. *   NAME
  32. *    SetString --
  33. *
  34. *   SYNOPSIS
  35. *    block_diff = SetString(field,new_str)
  36. *
  37. *    PINT SetString(TEXT **,TEXT *);
  38. *
  39. *   FUNCTION
  40. *
  41. *   INPUTS
  42. *
  43. *   RESULT
  44. *
  45. *   EXAMPLE
  46. *
  47. *   NOTES
  48. *
  49. *   BUGS
  50. *
  51. *   SEE ALSO
  52. *
  53. ****************************************************************************
  54. *
  55. */
  56.  
  57. PINT SetString(TEXT **field,const TEXT *new_str)
  58. {
  59.    LONG error;
  60.    UPINT length;
  61.    STRPTR str_copy,old_str;
  62.    PINT block_diff;
  63.  
  64.    /* Allocate new string */
  65.  
  66.    error=0;
  67.    length=0;
  68.    block_diff=0;
  69.    str_copy=NULL;
  70.    if(new_str!=NULL)
  71.    {
  72.       length=StrSize(new_str);
  73.       if(length>1)
  74.       {
  75.          str_copy=AllocMem(length,MEMF_ANY);
  76.          if(str_copy!=NULL)
  77.          {
  78.             CopyMem(new_str,str_copy,length);
  79.          }
  80.          else
  81.             error=IoErr();
  82.       }
  83.       else
  84.          length=0;
  85.    }
  86.  
  87.    if(error==0)
  88.    {
  89.       /* Deallocate old string */
  90.  
  91.       if(length>0)
  92.          block_diff=MEMBLOCKS(length);
  93.       length=0;
  94.       old_str=*field;
  95.       if(old_str!=NULL)
  96.       {
  97.          length=StrLen(old_str)+1;
  98.          FreeMem(old_str,length);
  99.          block_diff-=MEMBLOCKS(length);
  100.       }
  101.  
  102.       /* Store new string */
  103.  
  104.       *field=str_copy;
  105.    }
  106.  
  107.    /* Store secondary error and return difference in block utilisation */
  108.  
  109.    SetIoErr(error);
  110.    if(error!=0)
  111.       block_diff=-1;
  112.    return block_diff;
  113. }
  114.  
  115.  
  116.  
  117. /****i* ram.handler/SwapStrings ********************************************
  118. *
  119. *   NAME
  120. *    SwapStrings --
  121. *
  122. *   SYNOPSIS
  123. *    block_diff = SwapStrings(field1,field2)
  124. *
  125. *    PINT SetString(STRPTR *,STRPTR *);
  126. *
  127. *   FUNCTION
  128. *
  129. *   INPUTS
  130. *
  131. *   RESULT
  132. *
  133. *   EXAMPLE
  134. *
  135. *   NOTES
  136. *
  137. *   BUGS
  138. *
  139. *   SEE ALSO
  140. *
  141. ****************************************************************************
  142. *
  143. */
  144.  
  145. PINT SwapStrings(TEXT **field1,TEXT **field2)
  146. {
  147.    STRPTR str1,str2;
  148.    PINT block_diff;
  149.  
  150.    block_diff=0;
  151.  
  152.    str1=*field1;
  153.    if(str1!=NULL)
  154.       block_diff=MEMBLOCKS(StrSize(str1));
  155.  
  156.    str2=*field2;
  157.    if(str2!=NULL)
  158.       block_diff-=MEMBLOCKS(StrSize(str2));
  159.  
  160.    *field1=str2;
  161.    *field2=str1;
  162.  
  163.    /* Return difference in block utilisation */
  164.  
  165.    return block_diff;
  166. }
  167.  
  168.  
  169.  
  170. /****i* ram.handler/StrLen *************************************************
  171. *
  172. *   NAME
  173. *    StrLen --
  174. *
  175. *   SYNOPSIS
  176. *    length = StrLen(s)
  177. *
  178. *    UPINT StrLen(TEXT *);
  179. *
  180. *   FUNCTION
  181. *
  182. *   INPUTS
  183. *
  184. *   RESULT
  185. *
  186. *   EXAMPLE
  187. *
  188. *   NOTES
  189. *
  190. *   BUGS
  191. *
  192. *   SEE ALSO
  193. *
  194. ****************************************************************************
  195. *
  196. */
  197.  
  198. UPINT StrLen(const TEXT *s)
  199. {
  200.    const TEXT *p;
  201.  
  202.    for(p=s;*p!='\0';p++);
  203.    return p-s;
  204. }
  205.  
  206.  
  207.  
  208. /****i* ram.handler/StrSize ************************************************
  209. *
  210. *   NAME
  211. *    StrLen --
  212. *
  213. *   SYNOPSIS
  214. *    size = StrSize(s)
  215. *
  216. *    UPINT StrSize(TEXT *);
  217. *
  218. *   FUNCTION
  219. *
  220. *   INPUTS
  221. *
  222. *   RESULT
  223. *
  224. *   EXAMPLE
  225. *
  226. *   NOTES
  227. *
  228. *   BUGS
  229. *
  230. *   SEE ALSO
  231. *
  232. ****************************************************************************
  233. *
  234. */
  235.  
  236. UPINT StrSize(const TEXT *s)
  237. {
  238.    const TEXT *p;
  239.  
  240.    for(p=s;*p!='\0';p++);
  241.    return p-s+1;
  242. }
  243.  
  244.  
  245.  
  246. /****i* ram.handler/FindNameNoCase *****************************************
  247. *
  248. *   NAME
  249. *    FindNameNoCase --
  250. *
  251. *   SYNOPSIS
  252. *    node = FindNameNoCase(start,name)
  253. *
  254. *    struct Node *FindNameNoCase(struct List *,TEXT *);
  255. *
  256. *   FUNCTION
  257. *
  258. *   INPUTS
  259. *
  260. *   RESULT
  261. *
  262. *   EXAMPLE
  263. *
  264. *   NOTES
  265. *
  266. *   BUGS
  267. *
  268. *   SEE ALSO
  269. *
  270. ****************************************************************************
  271. *
  272. */
  273.  
  274. struct Node *FindNameNoCase(struct List *start,const TEXT *name)
  275. {
  276.    struct Node *node,*next_node,*matching_node;
  277.    STRPTR node_name;
  278.  
  279.    matching_node=NULL;
  280.    node=start->lh_Head;
  281.  
  282.    while(node!=NULL)
  283.    {
  284.       next_node=node->ln_Succ;
  285.       if(next_node!=NULL)
  286.       {
  287.          node_name=node->ln_Name;
  288.          if(node_name!=NULL)
  289.             if(Stricmp(name,node_name)==0)
  290.             {
  291.                matching_node=node;
  292.                next_node=NULL;
  293.             }
  294.       }
  295.       node=next_node;
  296.    }
  297.  
  298.    return matching_node;
  299. }
  300.  
  301.  
  302.  
  303. /****i* ram.handler/MyMakeDosEntry *****************************************
  304. *
  305. *   NAME
  306. *    MyMakeDosEntry --
  307. *
  308. *   SYNOPSIS
  309. *    dos_entry = MyMakeDosEntry(name,type)
  310. *
  311. *    struct DosList *MyMakeDosEntry(TEXT *,LONG);
  312. *
  313. *   FUNCTION
  314. *
  315. *   INPUTS
  316. *
  317. *   RESULT
  318. *
  319. *   EXAMPLE
  320. *
  321. *   NOTES
  322. *
  323. *   BUGS
  324. *
  325. *   SEE ALSO
  326. *
  327. ****************************************************************************
  328. *
  329. */
  330.  
  331. struct DosList *MyMakeDosEntry(const TEXT *name,LONG type)
  332. {
  333.    struct DosList *entry;
  334.    LONG error;
  335.  
  336.    error=0;
  337.    entry=AllocMem(sizeof(struct DosList),MEMF_CLEAR|MEMF_PUBLIC);
  338.  
  339.    if(entry!=NULL)
  340.    {
  341.       if(!MyRenameDosEntry(entry,name))
  342.          error=IoErr();
  343.       entry->dol_Type=type;
  344.    }
  345.    else
  346.       error=IoErr();
  347.  
  348.    if(error!=0)
  349.    {
  350.       MyFreeDosEntry(entry);
  351.       entry=NULL;
  352.    }
  353.  
  354.    SetIoErr(error);
  355.    return entry;
  356. }
  357.  
  358.  
  359.  
  360. /****i* ram.handler/MyFreeDosEntry *****************************************
  361. *
  362. *   NAME
  363. *    MyFreeDosEntry --
  364. *
  365. *   SYNOPSIS
  366. *    MyFreeDosEntry(entry)
  367. *
  368. *    VOID MyFreeDosEntry(struct DosList *);
  369. *
  370. *   FUNCTION
  371. *
  372. *   INPUTS
  373. *
  374. *   RESULT
  375. *
  376. *   EXAMPLE
  377. *
  378. *   NOTES
  379. *
  380. *   BUGS
  381. *
  382. *   SEE ALSO
  383. *
  384. ****************************************************************************
  385. *
  386. */
  387.  
  388. VOID MyFreeDosEntry(struct DosList *entry)
  389. {
  390.    if(entry!=NULL)
  391.    {
  392.       MyRenameDosEntry(entry,NULL);
  393.       FreeMem(entry,sizeof(struct DosList));
  394.    }
  395.  
  396.    return;
  397. }
  398.  
  399.  
  400.  
  401. /****i* ram.handler/MyRenameDosEntry ***************************************
  402. *
  403. *   NAME
  404. *    MyRenameDosEntry --
  405. *
  406. *   SYNOPSIS
  407. *    success = MyRenameDosEntry(entry,name)
  408. *
  409. *    BOOL MyRenameDosEntry(struct DosList *,TEXT *);
  410. *
  411. *   FUNCTION
  412. *
  413. *   INPUTS
  414. *
  415. *   RESULT
  416. *
  417. *   EXAMPLE
  418. *
  419. *   NOTES
  420. *
  421. *   BUGS
  422. *
  423. *   SEE ALSO
  424. *
  425. ****************************************************************************
  426. *
  427. */
  428.  
  429. BOOL MyRenameDosEntry(struct DosList *entry,const TEXT *name)
  430. {
  431.    LONG error;
  432.    UPINT length;
  433.    STRPTR name_copy,old_name;
  434.  
  435.    /* Allocate new string */
  436.  
  437.    error=0;
  438.    name_copy=NULL;
  439.    if(name!=NULL)
  440.    {
  441.       length=StrLen(name);
  442.       name_copy=AllocMem(length+2,MEMF_PUBLIC);
  443.       if(name_copy!=NULL)
  444.       {
  445.          CopyMem(name,name_copy+1,length+1);
  446.          *name_copy=length;
  447.       }
  448.       else
  449.          error=IoErr();
  450.    }
  451.  
  452.    /* Deallocate old string */
  453.  
  454.    if(error==0)
  455.    {
  456.       old_name=BADDR(entry->dol_Name);
  457.       if(old_name!=NULL)
  458.          FreeMem(old_name,*old_name+2);
  459.       entry->dol_Name=MKBADDR(name_copy);
  460.    }
  461.  
  462.    /* Store error code and return success flag */
  463.  
  464.    SetIoErr(error);
  465.    return error==0;
  466. }
  467.  
  468.  
  469.  
  470.